﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices; // 保留引用，用于其他潜在的P/Invoke调用
using System.Windows.Forms;
// 确保可以引用 DataRecoveryForm
// 添加对 DataRecoveryForm 的引用 - 如果是在同一个命名空间中，不需要额外的 using 语句

namespace BoringTodo
{
    public partial class Form1 : Form
    {
        // 数据管理器，用于加载和保存任务数据
        private readonly DataManager dataManager;
        private Settings settings;
        private readonly ScreenShot screenShot;

        // 用于绑定不同类型任务列表的数据源
        private BindingList<TodoItem> upTasks;        // UP类任务
        private BindingList<TodoItem> jumpTasks;      // jump类任务
        private BindingList<TodoItem> otherTasks;     // 其他类任务
        private BindingList<TodoItem> completedTasks;

        // 定时器，用于定期保存数据
        private Timer saveTimer;

        // 当前选中的DataGridView，用于确定用户操作的目标任务列表
        private DataGridView currentDataGridView;

        // 窗体的原始大小，用于在截图后恢复
        private Size originalFormSize;

        private ContextMenuStrip notifyIconContextMenu;

        private bool isFirstLoad = true;

        public Form1()
        {
            // 在初始化组件前先设置DPI感知
            try
            {
                SetProcessDPIAware();
            }
            catch
            {
                // 忽略可能的异常
            }
            
            InitializeComponent();
            
            // 添加Form加载完成事件处理
            this.Load += Form1_Load;
            
            try
            {
                Logger.Log("应用程序启动", LogLevel.Info);
                
                // 加载设置
                settings = Settings.Load();
                
            // 初始化数据管理器
                string myDocumentsPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                dataManager = new DataManager(myDocumentsPath);
                
                // 初始化截图管理器
                screenShot = new ScreenShot(myDocumentsPath);
                screenShot.ScreenshotCaptured += OnScreenshotCaptured;
                
            // 注册事件
            RegisterEvents();
                
            // 启动保存数据的定时器
            StartSaveTimer();

                // 根据设置启动截图定时器
                if (settings.EnableAutoScreenshot)
                {
                    screenShot.StartScreenshotTimer(settings.ScreenshotIntervalMinutes);
                }
                
                // 加载数据 - 由于是异步操作，需要等待数据加载完成后再初始化DataGridView
                LoadDataAndInitialize();
            }
            catch (Exception ex)
            {
                Logger.LogError("应用程序初始化失败", ex);
                MessageBox.Show($"初始化应用程序时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 表单加载完成后记录窗体原始大小并更新布局
        private void Form1_Load(object sender, EventArgs e)
        {
            // 记录窗体的原始大小（用于截图后恢复）
            originalFormSize = this.Size;
            
            // 更新控件布局以适应当前窗体大小
            UpdateLayout();
        }

        // 加载数据并初始化DataGridView
        private async void LoadDataAndInitialize()
        {
            try
            {
                // 设置进程为DPI感知
                SetProcessDPIAware();
                
                // 记录原始窗体大小，用于后续DPI缩放处理
                originalFormSize = this.Size;
                
                // 预先设置待办任务和已完成任务列表
                upTasks = new BindingList<TodoItem>();
                jumpTasks = new BindingList<TodoItem>();
                otherTasks = new BindingList<TodoItem>();
                completedTasks = new BindingList<TodoItem>();
                
                // 加载用户数据 - 修复类型参数错误
                await LoadAllDataAsync();
                
                // 初始化DataGridView的显示设置
                InitializeDataGrids();
                
                Logger.Log("数据加载和初始化完成", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("数据加载和初始化失败", ex);
                MessageBox.Show($"加载数据时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        
        // 初始化DataGridView的数据源和格式
        private void InitializeDataGrids()
        {
            dataGridView1.SuspendLayout();
            dataGridView2.SuspendLayout();
            dataGridView3.SuspendLayout();
            dataGridView4.SuspendLayout();
            
            // 设置DataGridView的数据源
            dataGridView1.DataSource = upTasks;
            SetDataGridViewColumnWidths(dataGridView1);
            HideEnglishColumns(dataGridView1);

            dataGridView2.DataSource = jumpTasks;
            SetDataGridViewColumnWidths(dataGridView2);
            HideEnglishColumns(dataGridView2);

            dataGridView3.DataSource = otherTasks;
            SetDataGridViewColumnWidths(dataGridView3);
            HideEnglishColumns(dataGridView3);

            dataGridView4.DataSource = completedTasks;
            SetDataGridViewColumnWidths(dataGridView4);
            HideEnglishColumns(dataGridView4);

            SetDateTimeColumnFormat(dataGridView1);
            SetDateTimeColumnFormat(dataGridView2);
            SetDateTimeColumnFormat(dataGridView3);
            SetDateTimeColumnFormat(dataGridView4);
            
            // 设置任务类型列的单元格格式
            ConfigureTaskTypeColumn(dataGridView1);
            ConfigureTaskTypeColumn(dataGridView2);
            ConfigureTaskTypeColumn(dataGridView3);
            ConfigureTaskTypeColumn(dataGridView4);
            
            // 禁用手动调整行高
            dataGridView1.AllowUserToResizeRows = false;
            dataGridView2.AllowUserToResizeRows = false;
            dataGridView3.AllowUserToResizeRows = false;
            dataGridView4.AllowUserToResizeRows = false;
            
            // 调整列顺序 - 将任务类型列移到前面
            AdjustColumnOrder(dataGridView1);
            AdjustColumnOrder(dataGridView2);
            AdjustColumnOrder(dataGridView3);
            AdjustColumnOrder(dataGridView4);
            
            dataGridView1.ResumeLayout();
            dataGridView2.ResumeLayout();
            dataGridView3.ResumeLayout();
            dataGridView4.ResumeLayout();
        }
        
        // 调整DataGridView列顺序，使任务类型列显示在前面
        private void AdjustColumnOrder(DataGridView dgv)
        {
            try
            {
                if (dgv.Columns.Contains("任务类型"))
                {
                    // 将任务类型列移动到第一列
                    DataGridViewColumn typeColumn = dgv.Columns["任务类型"];
                    
                    // 如果任务类型列不在第一位，则调整顺序
                    if (typeColumn.DisplayIndex > 0)
                    {
                        typeColumn.DisplayIndex = 0;
                        Logger.Log("调整列顺序：任务类型列移到最前", LogLevel.Info);
                    }
                    
                    // 确保描述列在任务类型列后面
                    if (dgv.Columns.Contains("描述"))
                    {
                        dgv.Columns["描述"].DisplayIndex = 1;
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.LogError("调整列顺序失败", ex);
            }
        }
        
        // 配置任务类型列的显示格式
        private void ConfigureTaskTypeColumn(DataGridView dgv)
        {
            if (dgv.Columns.Contains("任务类型"))
            {
                // 为任务类型列设置不同的背景色
                dgv.CellFormatting += (sender, e) => 
                {
                    if (e.ColumnIndex == dgv.Columns["任务类型"].Index && e.RowIndex >= 0)
                    {
                        if (e.Value != null)
                        {
                            var taskType = (TaskType)e.Value;
                            if (taskType == TaskType.UP类)
                            {
                                e.CellStyle.BackColor = Color.LightBlue;
                                e.CellStyle.ForeColor = Color.DarkBlue;
                                e.CellStyle.Font = new Font(dgv.Font, FontStyle.Bold);
                            }
                            else if (taskType == TaskType.jump类)
                            {
                                e.CellStyle.BackColor = Color.LightGreen;
                                e.CellStyle.ForeColor = Color.DarkGreen;
                                e.CellStyle.Font = new Font(dgv.Font, FontStyle.Bold);
                            }
                            else
                            {
                                e.CellStyle.BackColor = Color.LightGray;
                                e.CellStyle.ForeColor = Color.DarkGray;
                            }
                        }
                    }
                };
            }
        }
        
        // 隐藏英文列名
        private void HideEnglishColumns(DataGridView dgv)
        {
            // 隐藏英文列
            if (dgv.Columns.Contains("Description"))
                dgv.Columns["Description"].Visible = false;
                
            if (dgv.Columns.Contains("Notes"))
                dgv.Columns["Notes"].Visible = false;
                
            if (dgv.Columns.Contains("CreationDate"))
                dgv.Columns["CreationDate"].Visible = false;
                
            if (dgv.Columns.Contains("CompletionDate"))
                dgv.Columns["CompletionDate"].Visible = false;
                
            if (dgv.Columns.Contains("IsCompleted"))
                dgv.Columns["IsCompleted"].Visible = false;
                
            if (dgv.Columns.Contains("TaskTypeValue"))
                dgv.Columns["TaskTypeValue"].Visible = false;
                
            // 隐藏Error列
            if (dgv.Columns.Contains("Error"))
                dgv.Columns["Error"].Visible = false;
                
            if (dgv.Columns.Contains("错误"))
                dgv.Columns["错误"].Visible = false;
        }

        // 设置DataGridView的列宽
        private void SetDataGridViewColumnWidths(DataGridView dgv)
        {
            if (dgv.Columns.Contains("描述"))
            {
                dgv.Columns["描述"].Width = 450;
                if (dgv == dataGridView1)
                {
                    dgv.Columns["描述"].HeaderText = "UP类任务描述";
                }
                else if (dgv == dataGridView2)
                {
                    dgv.Columns["描述"].HeaderText = "jump类任务描述";
                }
                else if (dgv == dataGridView3)
                {
                    dgv.Columns["描述"].HeaderText = "其他类任务描述";
                }
                else if (dgv == dataGridView4)
                {
                    dgv.Columns["描述"].HeaderText = "已完成任务描述";
                }
                dgv.Columns["描述"].DefaultCellStyle.Padding = new Padding(5, 2, 5, 2);
            }
            if (dgv.Columns.Contains("预期完成时间"))
            {
                dgv.Columns["预期完成时间"].Width = 180;
                dgv.Columns["预期完成时间"].HeaderText = "预期完成时间";
                dgv.Columns["预期完成时间"].DefaultCellStyle.Padding = new Padding(5, 2, 5, 2);
            }
            if (dgv.Columns.Contains("完成时间"))
            {
                dgv.Columns["完成时间"].Width = 180;
                dgv.Columns["完成时间"].HeaderText = "完成时间";
                dgv.Columns["完成时间"].DefaultCellStyle.Padding = new Padding(5, 2, 5, 2);
            }
            if (dgv.Columns.Contains("备注"))
            {
                dgv.Columns["备注"].Width = 300;
                dgv.Columns["备注"].HeaderText = "备注";
                dgv.Columns["备注"].DefaultCellStyle.Padding = new Padding(5, 2, 5, 2);
            }
            if (dgv.Columns.Contains("任务类型"))
            {
                dgv.Columns["任务类型"].Width = 120;
                dgv.Columns["任务类型"].HeaderText = "任务类型";
                dgv.Columns["任务类型"].DefaultCellStyle.Padding = new Padding(5, 2, 5, 2);
                dgv.Columns["任务类型"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
            
            // 为所有列设置居中对齐
            foreach (DataGridViewColumn column in dgv.Columns)
            {
                column.HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
                if (column.ValueType == typeof(DateTime) || column.ValueType == typeof(DateTime?))
                {
                    column.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                }
            }
        }

        // 设置DataGridView的日期列格式
        private void SetDateTimeColumnFormat(DataGridView dgv)
        {
            foreach (DataGridViewColumn column in dgv.Columns)
            {
                if (column.ValueType == typeof(DateTime) || column.ValueType == typeof(DateTime?))
                {
                    column.DefaultCellStyle.Format = "yyyy-MM-dd HH:mm";
                    column.DefaultCellStyle.NullValue = "";
                }
            }
        }

        // 将选中的任务置顶
        private void MoveSelectedTaskToTop(DataGridView dgv, BindingList<TodoItem> sourceList)
        {
            if (dgv.SelectedRows.Count == 0)
            {
                MessageBox.Show("请先选择要置顶的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            try
            {
                // 获取选中的任务
                var selectedTask = (TodoItem)dgv.SelectedRows[0].DataBoundItem;
                
                // 从源列表中移除选中的任务
                sourceList.Remove(selectedTask);
                
                // 确定要插入的位置
                int insertIndex = 0;
                
                // 如果是杂活类型的任务，找到最后一个"有价值工作"类型的任务后面的位置插入
                if (selectedTask.任务类型 == TaskType.杂活)
                {
                    // 找到最后一个"有价值工作"类型任务的索引
                    for (int i = 0; i < sourceList.Count; i++)
                    {
                        if (sourceList[i].任务类型 == TaskType.有价值工作)
                        {
                            insertIndex = i + 1; // 插入到这个"有价值工作"之后
                        }
                        else
                        {
                            // 一旦遇到非"有价值工作"类型的任务，即可退出循环
                            break;
                        }
                    }
                }
                // 如果是"有价值工作"类型任务，直接插入到列表顶部
                
                // 将任务插入到确定的位置
                sourceList.Insert(insertIndex, selectedTask);
                
                // 刷新DataGridView
                dgv.ClearSelection();
                
                // 选中置顶后的任务行
                for (int i = 0; i < dgv.Rows.Count; i++)
                {
                    if (dgv.Rows[i].DataBoundItem == selectedTask)
                    {
                        dgv.Rows[i].Selected = true;
                        // 确保选中的行可见
                        dgv.FirstDisplayedScrollingRowIndex = i;
                        break;
                    }
                }
                    
                // 保存数据
                SaveCurrentData();
                Logger.Log($"任务已置顶到合适位置，任务类型：{selectedTask.任务类型}", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("置顶任务失败", ex);
                MessageBox.Show($"置顶任务时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 注册事件处理程序，包含数据错误处理和用户交互事件
        private void RegisterEvents()
        {
            dataGridView1.DataError += DataGridView_DataError;
            dataGridView2.DataError += DataGridView_DataError;
            dataGridView3.DataError += DataGridView_DataError;
            dataGridView4.DataError += DataGridView_DataError;

            // 修改Enter事件处理器，设置当前DataGridView并清除其他DataGridView的选择
            dataGridView1.Enter += (s, e) => {
                currentDataGridView = dataGridView1;
                // 清除其他DataGridView的选择
                ClearOtherDataGridViewSelection(dataGridView1);
            };
            
            dataGridView2.Enter += (s, e) => {
                currentDataGridView = dataGridView2;
                // 清除其他DataGridView的选择
                ClearOtherDataGridViewSelection(dataGridView2);
            };
            
            dataGridView3.Enter += (s, e) => {
                currentDataGridView = dataGridView3;
                // 清除其他DataGridView的选择
                ClearOtherDataGridViewSelection(dataGridView3);
            };
            
            dataGridView4.Enter += (s, e) => {
                currentDataGridView = dataGridView4;
                // 清除其他DataGridView的选择
                ClearOtherDataGridViewSelection(dataGridView4);
            };

            dataGridView1.UserDeletingRow += DataGridView_UserDeletingRow;
            dataGridView2.UserDeletingRow += DataGridView_UserDeletingRow;
            dataGridView3.UserDeletingRow += DataGridView_UserDeletingRow;
            dataGridView4.UserDeletingRow += DataGridView_UserDeletingRow;

            // 添加选中行改变事件
            dataGridView1.SelectionChanged += DataGridView_SelectionChanged;
            dataGridView2.SelectionChanged += DataGridView_SelectionChanged;
            dataGridView3.SelectionChanged += DataGridView_SelectionChanged;
            dataGridView4.SelectionChanged += DataGridView_SelectionChanged;
            
            // 添加双击事件处理
            dataGridView1.CellDoubleClick += DataGridView_CellDoubleClick;
            dataGridView2.CellDoubleClick += DataGridView_CellDoubleClick;
            dataGridView3.CellDoubleClick += DataGridView_CellDoubleClick;
            dataGridView4.CellDoubleClick += DataGridView_CellDoubleClick;
            
            // 设置右键菜单
            InitializeContextMenus();

            FormClosing += Form1_FormClosing;

            // 添加键盘快捷键
            this.KeyPreview = true;
            this.KeyDown += (s, e) => {
                if (e.Control && e.KeyCode == Keys.S)
                {
                    SaveAllData();
                    e.Handled = true;
                    Logger.Log("使用快捷键保存数据", LogLevel.Info);
                }
            };
        }
        
        // 修改为当一个DataGridView获取选择时清除另一个DataGridView的选择
        private bool isProcessingSelectionChange = false; // 添加标志防止无限递归
        
        private void DataGridView_SelectionChanged(object sender, EventArgs e)
        {
            // 如果正在处理选择改变事件，则直接返回，避免无限递归
            if (isProcessingSelectionChange)
                return;
                
            var dgv = (DataGridView)sender;
            
            // 设置当前DataGridView
            currentDataGridView = dgv;

            // 清除所有行的背景色
            foreach (DataGridViewRow row in dgv.Rows)
            {
                row.DefaultCellStyle.BackColor = Color.White;
            }

            // 设置新选中行的背景色
            if (dgv.SelectedRows.Count > 0)
            {
                dgv.SelectedRows[0].DefaultCellStyle.BackColor = Color.LightSkyBlue;
                
                // 设置标志，防止无限递归
                isProcessingSelectionChange = true;
                try
                {
                    // 清除其他DataGridView的选择
                    ClearOtherDataGridViewSelection(dgv);
                }
                finally
                {
                    // 重置标志
                    isProcessingSelectionChange = false;
                }
            }
        }
        
        // 处理DataGridView单元格双击事件
        private void DataGridView_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.RowIndex >= 0)  // 确保不是标题行
            {
                var dgv = (DataGridView)sender;
                
                // 安全检查 - 确保行索引在有效范围内
                if (e.RowIndex >= dgv.Rows.Count)
                {
                    return;
                }
                
                // 安全检查 - 确保行有关联的数据项
                if (dgv.Rows[e.RowIndex].DataBoundItem == null)
                {
                    MessageBox.Show("找不到任务数据。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                
                // 确保关联的数据项是TodoItem
                if (!(dgv.Rows[e.RowIndex].DataBoundItem is TodoItem))
                {
                    MessageBox.Show("数据类型不正确。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                
                // 设置当前DataGridView，并清除另一个表格的选择
                currentDataGridView = dgv;
                
                // 如果当前是未完成任务表格，则清除已完成任务表格的选择
                if (dgv == dataGridView1 && dataGridView4.SelectedRows.Count > 0)
                {
                    dataGridView4.ClearSelection();
                }
                // 如果当前是已完成任务表格，则清除未完成任务表格的选择
                else if (dgv == dataGridView4 && dataGridView1.SelectedRows.Count > 0)
                {
                    dataGridView1.ClearSelection();
                }
                
                // 确保当前行被选中
                if (dgv.SelectedRows.Count == 0)
                {
                    dgv.Rows[e.RowIndex].Selected = true;
                }
                
                // 编辑当前选中的任务
                EditCurrentTask();
            }
        }
        
        // 初始化右键菜单
        private void InitializeContextMenus()
        {
            // 为UP类任务创建上下文菜单
            var upContextMenu = new ContextMenuStrip();
            upContextMenu.Items.Add("编辑任务", null, (s, e) => EditCurrentTask());
            upContextMenu.Items.Add("删除任务", null, (s, e) => BtnDeleteTask_Click(s, e));
            upContextMenu.Items.Add("标记为完成", null, (s, e) => BtnMarkAsComplete_Click(s, e));
            upContextMenu.Items.Add("置顶", null, (s, e) => BtnMoveToTop_Click(s, e));
            
            // 为jump类任务创建上下文菜单
            var jumpContextMenu = new ContextMenuStrip();
            jumpContextMenu.Items.Add("编辑任务", null, (s, e) => EditCurrentTask());
            jumpContextMenu.Items.Add("删除任务", null, (s, e) => BtnDeleteTask_Click(s, e));
            jumpContextMenu.Items.Add("标记为完成", null, (s, e) => BtnMarkAsComplete_Click(s, e));
            jumpContextMenu.Items.Add("置顶", null, (s, e) => BtnMoveToTop_Click(s, e));
            
            // 为其他类任务创建上下文菜单
            var otherContextMenu = new ContextMenuStrip();
            otherContextMenu.Items.Add("编辑任务", null, (s, e) => EditCurrentTask());
            otherContextMenu.Items.Add("删除任务", null, (s, e) => BtnDeleteTask_Click(s, e));
            otherContextMenu.Items.Add("标记为完成", null, (s, e) => BtnMarkAsComplete_Click(s, e));
            otherContextMenu.Items.Add("置顶", null, (s, e) => BtnMoveToTop_Click(s, e));
            
            // 为已完成任务创建上下文菜单
            var completedContextMenu = new ContextMenuStrip();
            completedContextMenu.Items.Add("编辑任务", null, (s, e) => EditCurrentTask());
            completedContextMenu.Items.Add("删除任务", null, (s, e) => BtnDeleteTask_Click(s, e));
            completedContextMenu.Items.Add("恢复为待办", null, (s, e) => BtnRestoreTask_Click(s, e));
            completedContextMenu.Items.Add("置顶", null, (s, e) => BtnMoveToTop_Click(s, e));
            
            // 设置所有DataGridView的上下文菜单
            dataGridView1.ContextMenuStrip = upContextMenu;
            dataGridView2.ContextMenuStrip = jumpContextMenu;
            dataGridView3.ContextMenuStrip = otherContextMenu;
            dataGridView4.ContextMenuStrip = completedContextMenu;
            
            // 上下文菜单打开前清除其他DataGridView的选择
            upContextMenu.Opening += (s, e) => ClearOtherDataGridViewSelection(dataGridView1);
            jumpContextMenu.Opening += (s, e) => ClearOtherDataGridViewSelection(dataGridView2);
            otherContextMenu.Opening += (s, e) => ClearOtherDataGridViewSelection(dataGridView3);
            completedContextMenu.Opening += (s, e) => ClearOtherDataGridViewSelection(dataGridView4);
        }
        
        // 编辑当前选中的任务
        private void EditCurrentTask()
        {
            // 验证是否有有效的DataGridView和选中的行
            if (currentDataGridView == null)
            {
                MessageBox.Show("请先选择要编辑的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
            
            if (currentDataGridView.SelectedRows.Count == 0)
            {
                // 尝试选择当前单元格所在行
                if (currentDataGridView.CurrentCell != null)
                {
                    int rowIndex = currentDataGridView.CurrentCell.RowIndex;
                    
                    // 安全检查 - 确保行索引在有效范围内
                    if (rowIndex >= 0 && rowIndex < currentDataGridView.Rows.Count)
                    {
                        currentDataGridView.Rows[rowIndex].Selected = true;
                    }
                }
                
                // 如果仍然没有选中行，显示提示
                if (currentDataGridView.SelectedRows.Count == 0)
                {
                    MessageBox.Show("请先选择要编辑的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
            }

            try
            {
                // 获取选中的任务
                var selectedRow = currentDataGridView.SelectedRows[0];
                
                // 安全检查 - 确保行有关联的数据项
                if (selectedRow.DataBoundItem == null)
                {
                    MessageBox.Show("找不到任务数据。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                
                // 确保关联的数据项是TodoItem
                if (!(selectedRow.DataBoundItem is TodoItem))
                {
                    MessageBox.Show("数据类型不正确。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                
                var selectedTask = (TodoItem)selectedRow.DataBoundItem;
                TaskType originalTaskType = selectedTask.任务类型; // 保存原始任务类型
                bool wasCompleted = selectedTask.IsCompleted;

                using (var editForm = new EditTaskForm(selectedTask))
                {
                    if (editForm.ShowDialog() == DialogResult.OK)
                    {
                        // 如果任务类型改变且是待办任务，则重新分配任务到相应的列表
                        if (originalTaskType != selectedTask.任务类型)
                        {
                            // 从原列表中移除任务
                            BindingList<TodoItem> sourceList = (BindingList<TodoItem>)currentDataGridView.DataSource;
                            sourceList.Remove(selectedTask);
                            
                            // 根据新类型添加到相应的列表
                            BindingList<TodoItem> targetList;
                            DataGridView targetGridView;
                            
                            switch (selectedTask.任务类型)
                            {
                                case TaskType.UP类:
                                    targetList = upTasks;
                                    targetGridView = dataGridView1;
                                    break;
                                case TaskType.jump类:
                                    targetList = jumpTasks;
                                    targetGridView = dataGridView2;
                                    break;
                                case TaskType.其他类:
                                default:
                                    targetList = otherTasks;
                                    targetGridView = dataGridView3;
                                    break;
                            }
                            
                            targetList.Add(selectedTask);
                            
                            // 切换到目标DataGridView并选中任务
                            currentDataGridView = targetGridView;
                            int taskIndex = targetList.IndexOf(selectedTask);
                            if (taskIndex >= 0 && taskIndex < targetGridView.Rows.Count)
                            {
                                targetGridView.ClearSelection();
                                targetGridView.Rows[taskIndex].Selected = true;
                                targetGridView.FirstDisplayedScrollingRowIndex = taskIndex;
                            }
                        }
                        
                        // 刷新 DataGridView 以显示更新后的数据
                        currentDataGridView.Refresh();
                        SaveCurrentData();
                        
                        Logger.Log($"编辑任务: {selectedTask.描述}", LogLevel.Info);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.LogError("编辑任务失败", ex);
                MessageBox.Show($"编辑任务时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 修改为只设置当前DataGridView，不清除选择
        private void UpdateCurrentDataGridView(DataGridView dgv)
        {
            // 不清除所有选择，只设置当前DataGridView
            currentDataGridView = dgv;
        }

        // 清除所有DataGridView的选择
        private void ClearSelections()
        {
            dataGridView1.ClearSelection();
            dataGridView2.ClearSelection();
            dataGridView3.ClearSelection();
            dataGridView4.ClearSelection();
        }

        // 处理DataGridView的数据错误事件
        private void DataGridView_DataError(object sender, DataGridViewDataErrorEventArgs e)
        {
            Logger.Log($"数据格式错误: 行={e.RowIndex}, 列={e.ColumnIndex}", LogLevel.Warning);
            MessageBox.Show("数据格式错误，请检查输入的日期格式。", "数据错误", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            e.ThrowException = false;
        }

        // 处理DataGridView中的行删除事件，询问用户是否确认删除
        private void DataGridView_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
        {
            if (MessageBox.Show("确定要删除选中的任务吗？", "确认删除", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) != DialogResult.Yes)
            {
                e.Cancel = true;
            }
        }
        
        // 处理添加任务按钮的点击事件，添加新任务到相应的DataGridView
        private void BtnAddTask_Click(object sender, EventArgs e)
        {
            try
            {
                var newTask = new TodoItem
                {
                    描述 = "请输入任务的内容",
                    CreationDate = DateTime.Now,
                    预期完成时间 = DateTime.Now,
                    备注 = string.Empty,
                    任务类型 = TaskType.其他类  // 默认为"其他类"
                };
            
                using (var editForm = new EditTaskForm(newTask))
                {
                    if (editForm.ShowDialog() == DialogResult.OK)
                    {
                        // 确保所有任务列表已正确初始化
                        if (upTasks == null)
                        {
                            upTasks = new BindingList<TodoItem>();
                            dataGridView1.DataSource = upTasks;
                        }
                        if (jumpTasks == null)
                        {
                            jumpTasks = new BindingList<TodoItem>();
                            dataGridView2.DataSource = jumpTasks;
                        }
                        if (otherTasks == null)
                        {
                            otherTasks = new BindingList<TodoItem>();
                            dataGridView3.DataSource = otherTasks;
                        }
                        
                        // 清除所有DataGridView的选择
                        ClearSelections();
                        
                        // 根据任务类型添加到相应的列表中
                        BindingList<TodoItem> targetList;
                        DataGridView targetGridView;
                        
                        switch (newTask.任务类型)
                        {
                            case TaskType.UP类:
                                targetList = upTasks;
                                targetGridView = dataGridView1;
                                break;
                            case TaskType.jump类:
                                targetList = jumpTasks;
                                targetGridView = dataGridView2;
                                break;
                            case TaskType.其他类:
                            default:
                                targetList = otherTasks;
                                targetGridView = dataGridView3;
                                break;
                        }
                        
                        // 将当前DataGridView设置为目标表格
                        currentDataGridView = targetGridView;
                        
                        // 添加新任务到相应的列表
                        targetList.Add(newTask);
                        
                        // 保存当前数据
                        SaveCurrentData();
                        
                        // 自动选中新添加的任务
                        int taskIndex = targetList.IndexOf(newTask);
                        if (taskIndex >= 0 && taskIndex < targetGridView.Rows.Count)
                        {
                            targetGridView.ClearSelection();
                            targetGridView.Rows[taskIndex].Selected = true;
                            targetGridView.FirstDisplayedScrollingRowIndex = taskIndex;
                            
                            // 给新选中的行添加背景色
                            targetGridView.Rows[taskIndex].DefaultCellStyle.BackColor = Color.LightSkyBlue;
                        }
                        
                        Logger.Log($"添加新任务: {newTask.描述}", LogLevel.Info);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.LogError("添加任务失败", ex);
                MessageBox.Show($"添加任务时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 删除选定的任务
        private void BtnDeleteTask_Click(object sender, EventArgs e)
        {
            if (currentDataGridView == null) 
            {
                MessageBox.Show("请先选择要删除的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
            
            if (MessageBox.Show("确定要删除选中的任务吗？", "确认删除", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
            {
                try
            {
                var sourceList = (BindingList<TodoItem>)currentDataGridView.DataSource;
                int count = currentDataGridView.SelectedRows.Count;
                RemoveSelectedRows(currentDataGridView, sourceList);
                SaveCurrentData();
                
                Logger.Log($"删除了{count}个任务", LogLevel.Info);
                }
                catch (Exception ex)
                {
                    Logger.LogError("删除任务失败", ex);
                    MessageBox.Show($"删除任务时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }

        // 从DataGridView中移除选定的行
        private void RemoveSelectedRows(DataGridView dgv, BindingList<TodoItem> sourceList)
        {
            var itemsToRemove = dgv.SelectedRows.Cast<DataGridViewRow>()
                .Where(r => r.DataBoundItem is TodoItem)
                .Select(r => (TodoItem)r.DataBoundItem)
                .ToList();
                
            foreach (var item in itemsToRemove)
            {
                sourceList.Remove(item);
            }
        }

        // 标记任务为已完成
        private void BtnMarkAsComplete_Click(object sender, EventArgs e)
        {
            if (currentDataGridView == null)
            {
                MessageBox.Show("请先选择要完成的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
            
            try
            {
                int count = currentDataGridView.SelectedRows.Count;
                MoveCompletedTasks(currentDataGridView, (BindingList<TodoItem>)currentDataGridView.DataSource);
                SaveCurrentData();
                dataManager.SaveData(Constants.CompletedTasksFile, completedTasks);
                
                Logger.Log($"标记{count}个任务为已完成", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("标记任务完成失败", ex);
                MessageBox.Show($"标记任务完成时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 移动选中的任务到已完成列表
        private void MoveCompletedTasks(DataGridView dgv, BindingList<TodoItem> sourceList)
        {
            List<TodoItem> itemsToMove = dgv.SelectedRows.Cast<DataGridViewRow>()
                .Where(row => row.DataBoundItem is TodoItem)
                .Select(row =>
                {
                    var item = (TodoItem)row.DataBoundItem;
                    item.完成时间 = DateTime.Now;
                    completedTasks.Insert(0, item);
                    return item;
                }).ToList();

            foreach (var item in itemsToMove)
            {
                sourceList.Remove(item);
            }
            
            // 自动选中刚刚标记为完成的任务
            if (itemsToMove.Count > 0 && dataGridView4.Rows.Count > 0)
            {
                // 清除当前所有选择
                ClearSelections();
                
                // 将当前DataGridView设置为已完成任务表格
                currentDataGridView = dataGridView4;
                
                // 只选中第一行（刚刚标记完成的任务应该在顶部）
                dataGridView4.Rows[0].Selected = true;
                dataGridView4.FirstDisplayedScrollingRowIndex = 0;
                
                Logger.Log("自动选中刚完成的任务", LogLevel.Info);
            }
        }

        // 在窗体关闭时保存所有数据
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 如果是用户关闭窗口，最小化到系统托盘而不是关闭
            if (e.CloseReason == CloseReason.UserClosing)
            {
                e.Cancel = true;
                this.WindowState = FormWindowState.Minimized;
                this.ShowInTaskbar = false;
                notifyIcon1.Visible = true;
                
                // 首次最小化到托盘时显示气泡提示
                if (!Properties.Settings.Default.TrayNotificationShown)
                {
                    notifyIcon1.ShowBalloonTip(3000, "个人任务管理工具", 
                        "应用程序已最小化到系统托盘。双击图标可以重新打开窗口。", 
                        ToolTipIcon.Info);
                    Properties.Settings.Default.TrayNotificationShown = true;
                    Properties.Settings.Default.Save();
                }
            }
            else
            {
                // 其他关闭原因，例如系统关闭时，保存数据
                SaveAllData();
            }
        }

        private void notifyIcon1_MouseClick(object sender, MouseEventArgs e)
        {
            // 处理鼠标右击事件，显示上下文菜单
            if (e.Button == MouseButtons.Right)
            {
                // 初始化上下文菜单，如果尚未创建
                if (notifyIconContextMenu == null)
                {
                    notifyIconContextMenu = new ContextMenuStrip();
                    
                    // 添加"打开"选项
                    ToolStripMenuItem openMenuItem = new ToolStripMenuItem("打开窗口");
                    openMenuItem.Click += (s, args) => {
                        this.ShowInTaskbar = true;
                        this.WindowState = FormWindowState.Normal;
                        this.Activate();
                    };
                    notifyIconContextMenu.Items.Add(openMenuItem);
                    
                    notifyIconContextMenu.Items.Add(new ToolStripSeparator());
                    
                    // 添加"退出"选项
                    ToolStripMenuItem exitMenuItem = new ToolStripMenuItem("退出");
                    exitMenuItem.Click += (s, args) => {
                        ExitApplication();
                    };
                    notifyIconContextMenu.Items.Add(exitMenuItem);
                }
                
                // 设置上下文菜单
                notifyIcon1.ContextMenuStrip = notifyIconContextMenu;
            }
        }

        /// <summary>
        /// 退出应用程序，保存所有数据并关闭资源
        /// </summary>
        public void ExitApplication()
        {
            // 保存所有数据并退出
            try
            {
                SaveAllData();
                notifyIcon1.Visible = false;
                Application.Exit();
            }
            catch (Exception ex)
            {
                Logger.LogError("退出应用程序时出错", ex);
                notifyIcon1.Visible = false;
                Application.Exit();
            }
        }

        private void notifyIcon1_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                this.ShowInTaskbar = true;
                this.WindowState = FormWindowState.Normal;
                this.Activate();
            }
        }

        // 启动用于定时保存数据的计时器
        private void StartSaveTimer()
        {
            saveTimer = new Timer { Interval = Constants.DataSaveInterval * 60 * 1000 }; // 使用常量
            saveTimer.Tick += SaveTimer_Tick;
            saveTimer.Start();
            Logger.Log("自动保存计时器已启动", LogLevel.Info);
        }

        // 定期保存数据并更新即将到来的任务
        private void SaveTimer_Tick(object sender, EventArgs e)
        {
            SaveAllData();
        }

        // 保存所有任务列表的数据
        private async void SaveAllData()
        {
            try
            {
                // 合并所有待办任务到一个列表中进行保存
                var allTasks = new BindingList<TodoItem>();
                if (upTasks != null) 
                {
                    foreach (var task in upTasks)
                        allTasks.Add(task);
                }
                if (jumpTasks != null) 
                {
                    foreach (var task in jumpTasks)
                        allTasks.Add(task);
                }
                if (otherTasks != null) 
                {
                    foreach (var task in otherTasks)
                        allTasks.Add(task);
                }
                
                await Task.WhenAll(
                    dataManager.SaveDataAsync(Constants.NormalTasksFile, allTasks),
                    dataManager.SaveDataAsync(Constants.CompletedTasksFile, completedTasks)
                );
                Logger.Log("所有数据保存成功", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("保存所有数据失败", ex);
            }
        }

        // 保存当前活动DataGridView的数据
        private async void SaveCurrentData()
        {
            try
            {
                if (currentDataGridView == dataGridView1)
                {
                    await dataManager.SaveDataAsync(Constants.NormalTasksFile, upTasks);
                }
                else if (currentDataGridView == dataGridView2)
                {
                    await dataManager.SaveDataAsync(Constants.NormalTasksFile, jumpTasks);
                }
                else if (currentDataGridView == dataGridView3)
                {
                    await dataManager.SaveDataAsync(Constants.NormalTasksFile, otherTasks);
                }
                else if (currentDataGridView == dataGridView4)
                {
                    await dataManager.SaveDataAsync(Constants.CompletedTasksFile, completedTasks);
                }
            }
            catch (Exception ex)
            {
                Logger.LogError("保存当前数据失败", ex);
            }
        }

        // 截图完成后的事件处理
        private void OnScreenshotCaptured(object sender, string path)
        {
            // 在UI线程上执行
            this.BeginInvoke(new Action(() =>
            {
                // 保持窗体大小不变
                DpiHandler.PreserveFormSize(this, originalFormSize);
                
                Logger.Log($"截图已保存: {path}", LogLevel.Info);
            }));
        }

        // 添加截图按钮点击事件处理程序
        private async void btnScreenshot_Click(object sender, EventArgs e)
        {
            try
            {
                // 显示操作正在进行的消息
                this.UseWaitCursor = true;
                Logger.Log("用户点击截图按钮，开始截图流程", LogLevel.Info);
                
                // 记录当前窗体大小
                Size currentSize = this.Size;
                
                // 尝试最小化窗口以避免捕获到应用程序自身
                this.WindowState = FormWindowState.Minimized;
                Application.DoEvents(); // 给窗口状态变化一些时间
                System.Threading.Thread.Sleep(500); // 稍微等待以确保窗口最小化
                
                Logger.Log("窗口已最小化，即将开始截图", LogLevel.Info);
                
                // 执行截图操作
                string screenshotPath = await screenShot.CaptureAndSaveAsync();
                
                // 恢复窗体状态
                this.WindowState = FormWindowState.Normal;
                
                // 恢复窗体大小
                DpiHandler.PreserveFormSize(this, currentSize);
                this.UseWaitCursor = false;
                
                if (!string.IsNullOrEmpty(screenshotPath) && File.Exists(screenshotPath))
                {
                    long fileSize = new FileInfo(screenshotPath).Length;
                    Logger.Log($"截图成功: {screenshotPath}, 大小: {fileSize} 字节", LogLevel.Info);
                    
                    MessageBox.Show($"截图已保存到:\n{screenshotPath}", "截图成功", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    
                    // 尝试打开截图所在文件夹
                    try
                    {
                        string folder = Path.GetDirectoryName(screenshotPath);
                        System.Diagnostics.Process.Start("explorer.exe", folder);
                    }
                    catch (Exception folderEx)
                    {
                        Logger.LogError($"无法打开截图文件夹: {folderEx.Message}", folderEx);
                    }
            }
            else
            {
                    Logger.LogError("截图路径为空或文件不存在", null);
                    MessageBox.Show("截图操作可能失败，未能找到保存的文件。\n请检查日志获取更多信息。", "截图警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            }
            catch (Exception ex)
            {
                Logger.LogError($"截图失败: {ex.Message}", ex);
                this.UseWaitCursor = false;
                this.WindowState = FormWindowState.Normal;
                
                MessageBox.Show(
                    $"截图失败: {ex.Message}\n\n可能的原因:\n" +
                    "1. 无法访问目标文件夹\n" +
                    "2. 磁盘空间不足\n" +
                    "3. 没有足够的系统权限\n\n" +
                    $"请确保程序对 '我的文档\\{Constants.AppDataFolder}\\{Constants.ScreenshotsFolder}' 有写入权限",
                    "截图错误",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        // 设置按钮点击事件处理程序
        private void btnSettings_Click(object sender, EventArgs e)
        {
            SettingsForm settingsForm = new SettingsForm(settings, screenShot);
            if (settingsForm.ShowDialog() == DialogResult.OK)
            {
                // 保存设置
                settings = Settings.Load();
                
                // 重新配置截图定时器
                if (settings.EnableAutoScreenshot)
                {
                    screenShot.StartScreenshotTimer(settings.ScreenshotIntervalMinutes);
                }
                else
                {
                    screenShot.StopScreenshotTimer();
                }
                
                Logger.Log("设置已更新", LogLevel.Info);
            }
        }

        private void BtnMoveToTop_Click(object sender, EventArgs e)
        {
            if (currentDataGridView != null)
            {
                var sourceList = (BindingList<TodoItem>)currentDataGridView.DataSource;
                MoveSelectedTaskToTop(currentDataGridView, sourceList);
                SaveCurrentData();
            }
        }

        private void BtnEditTask_Click(object sender, EventArgs e)
        {
            EditCurrentTask();
        }

        // 恢复任务按钮点击事件处理程序
        private void BtnRestoreTask_Click(object sender, EventArgs e)
        {
            if (currentDataGridView == null || currentDataGridView != dataGridView4)
            {
                MessageBox.Show("请先选择要恢复的已完成任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
            
            try
            {
                int count = currentDataGridView.SelectedRows.Count;
                if (count == 0)
                {
                    MessageBox.Show("请先选择要恢复的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                
                RestoreTasks(currentDataGridView, completedTasks);
                SaveCurrentData();
                
                Logger.Log($"已将{count}个任务恢复为待办状态", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("恢复任务失败", ex);
                MessageBox.Show($"恢复任务时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        
        // 将已完成任务恢复为待办任务
        private void RestoreTasks(DataGridView dgv, BindingList<TodoItem> completedList)
        {
            List<TodoItem> itemsToRestore = dgv.SelectedRows.Cast<DataGridViewRow>()
                .Where(row => row.DataBoundItem is TodoItem)
                .Select(row =>
                {
                    var item = (TodoItem)row.DataBoundItem;
                    item.完成时间 = null; // 清除完成时间
                    
                    // 根据任务类型添加到相应的列表中
                    switch (item.任务类型)
                    {
                        case TaskType.UP类:
                            upTasks.Insert(0, item);
                            break;
                        case TaskType.jump类:
                            jumpTasks.Insert(0, item);
                            break;
                        case TaskType.其他类:
                        default:
                            otherTasks.Insert(0, item);
                            break;
                    }
                    
                    return item;
                }).ToList();

            foreach (var item in itemsToRestore)
            {
                completedList.Remove(item);
            }
            
            // 自动选中刚刚恢复的任务
            if (itemsToRestore.Count > 0)
            {
                // 清除所有选择
                ClearSelections();
                
                // 找到第一个恢复的任务并选中它
                var firstItem = itemsToRestore[0];
                DataGridView targetGridView;
                BindingList<TodoItem> targetList;
                
                switch (firstItem.任务类型)
                {
                    case TaskType.UP类:
                        targetGridView = dataGridView1;
                        targetList = upTasks;
                        break;
                    case TaskType.jump类:
                        targetGridView = dataGridView2;
                        targetList = jumpTasks;
                        break;
                    case TaskType.其他类:
                    default:
                        targetGridView = dataGridView3;
                        targetList = otherTasks;
                        break;
                }
                
                // 将当前DataGridView设置为目标表格
                currentDataGridView = targetGridView;
                
                int taskIndex = targetList.IndexOf(firstItem);
                if (taskIndex >= 0 && taskIndex < targetGridView.Rows.Count)
                {
                    targetGridView.Rows[taskIndex].Selected = true;
                    targetGridView.FirstDisplayedScrollingRowIndex = taskIndex;
                }
                
                Logger.Log("自动选中刚恢复的任务", LogLevel.Info);
            }
        }

        // 上下文菜单打开前清除另一个DataGridView的选择
        private void ClearOtherDataGridViewSelection(DataGridView currentDgv)
        {
            // 临时禁用所有DataGridView的SelectionChanged事件，避免无限递归
            dataGridView1.SelectionChanged -= DataGridView_SelectionChanged;
            dataGridView2.SelectionChanged -= DataGridView_SelectionChanged;
            dataGridView3.SelectionChanged -= DataGridView_SelectionChanged;
            dataGridView4.SelectionChanged -= DataGridView_SelectionChanged;
            
            try
            {
                if (currentDgv == dataGridView1)
                {
                    // 如果当前操作的是UP类任务表格，清除其他表格的选择
                    dataGridView2.ClearSelection();
                    dataGridView3.ClearSelection();
                    dataGridView4.ClearSelection();
                    currentDataGridView = dataGridView1;
                }
                else if (currentDgv == dataGridView2)
                {
                    // 如果当前操作的是jump类任务表格，清除其他表格的选择
                    dataGridView1.ClearSelection();
                    dataGridView3.ClearSelection();
                    dataGridView4.ClearSelection();
                    currentDataGridView = dataGridView2;
                }
                else if (currentDgv == dataGridView3)
                {
                    // 如果当前操作的是其他类任务表格，清除其他表格的选择
                    dataGridView1.ClearSelection();
                    dataGridView2.ClearSelection();
                    dataGridView4.ClearSelection();
                    currentDataGridView = dataGridView3;
                }
                else if (currentDgv == dataGridView4)
                {
                    // 如果当前操作的是已完成任务表格，清除其他表格的选择
                    dataGridView1.ClearSelection();
                    dataGridView2.ClearSelection();
                    dataGridView3.ClearSelection();
                    currentDataGridView = dataGridView4;
                }
                
                // 确保鼠标右键点击的行被选中
                Point mousePosition = currentDgv.PointToClient(Control.MousePosition);
                DataGridView.HitTestInfo hitTestInfo = currentDgv.HitTest(mousePosition.X, mousePosition.Y);
                
                if (hitTestInfo.RowIndex >= 0 && hitTestInfo.RowIndex < currentDgv.Rows.Count)
                {
                    currentDgv.ClearSelection();
                    currentDgv.Rows[hitTestInfo.RowIndex].Selected = true;
                }
            }
            finally
            {
                // 重新启用所有DataGridView的SelectionChanged事件
                dataGridView1.SelectionChanged += DataGridView_SelectionChanged;
                dataGridView2.SelectionChanged += DataGridView_SelectionChanged;
                dataGridView3.SelectionChanged += DataGridView_SelectionChanged;
                dataGridView4.SelectionChanged += DataGridView_SelectionChanged;
            }
        }

        // 设置进程为DPI感知
        [DllImport("user32.dll")]
        private static extern bool SetProcessDPIAware();

        // 优化布局方法，使用相对定位和比例计算而非硬编码的位置和大小
        private void UpdateLayout()
        {
            try
            {
                // 我们不再需要手动设置控件的位置和大小
                // 所有控件的布局将通过Designer文件中的Anchor和Dock属性自动处理
                
                // 刷新控件
                dataGridView1.Refresh();
                dataGridView2.Refresh();
                dataGridView3.Refresh();
                dataGridView4.Refresh();
            }
            catch (Exception ex)
            {
                // 记录布局调整错误
                Logger.LogError("调整UI布局失败", ex);
            }
        }

        private void btnGeneratePrompt_Click(object sender, EventArgs e)
        {
            try
            {
                // 计算7天前的日期
                DateTime sevenDaysAgo = DateTime.Now.AddDays(-7);
                
                // 过滤过去7天内完成的任务
                var recentCompletedTasks = completedTasks
                    .Where(task => task.完成时间.HasValue && task.完成时间.Value >= sevenDaysAgo)
                    .OrderByDescending(task => task.完成时间)
                    .ToList();
                
                if (recentCompletedTasks.Count == 0)
                {
                    MessageBox.Show("过去7天内没有完成的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                
                // 构建要发送给AI的提示词
                StringBuilder promptBuilder = new StringBuilder();
                promptBuilder.AppendLine(settings.ExplanationText);
                promptBuilder.AppendLine();
                
                int index = 1;
                foreach (var task in recentCompletedTasks)
                {
                    // 添加完成日期和时间
                    string completionTime = task.完成时间.HasValue ? 
                        task.完成时间.Value.ToString("yyyy-MM-dd HH:mm") : "未知时间";
                    
                    // 添加任务描述
                    promptBuilder.AppendLine($"{index}. {task.描述} (完成于: {completionTime})");
                    
                    // 如果有备注，也添加进去
                    if (!string.IsNullOrWhiteSpace(task.备注))
                    {
                        promptBuilder.AppendLine($"   备注: {task.备注}");
                    }
                    
                    index++;
                }
                
                // 将提示词内容复制到剪贴板
                string promptText = promptBuilder.ToString();
                Clipboard.SetText(promptText);
                
                // 询问用户是否要编辑提示词
                DialogResult result = MessageBox.Show(
                    "提示词已生成并复制到剪贴板。是否要编辑提示词？", 
                    "提示词已生成", 
                    MessageBoxButtons.YesNo, 
                    MessageBoxIcon.Information);
                
                if (result == DialogResult.Yes)
                {
                    // 显示编辑提示词的窗口
                    using (var editPromptForm = new EditPromptForm(promptText))
                    {
                        if (editPromptForm.ShowDialog() == DialogResult.OK)
                        {
                            // 用户修改了提示词，更新剪贴板
                            Clipboard.SetText(editPromptForm.PromptText);
                            MessageBox.Show("修改后的提示词已复制到剪贴板。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                    }
                }
                
                Logger.Log("生成提示词成功", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("生成提示词失败", ex);
                MessageBox.Show($"生成提示词失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void splitContainer2_Panel1_Paint(object sender, PaintEventArgs e)
        {

        }

        private void btnMonthlyReport_Click(object sender, EventArgs e)
        {
            try
            {
                // 计算30天前的日期
                DateTime thirtyDaysAgo = DateTime.Now.AddDays(-30);
                
                // 过滤过去30天内完成的任务
                var recentCompletedTasks = completedTasks
                    .Where(task => task.完成时间.HasValue && task.完成时间.Value >= thirtyDaysAgo)
                    .OrderByDescending(task => task.完成时间)
                    .ToList();
                
                if (recentCompletedTasks.Count == 0)
                {
                    MessageBox.Show("过去30天内没有完成的任务。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                
                // 构建要发送给AI的提示词
                StringBuilder promptBuilder = new StringBuilder();
                promptBuilder.AppendLine(settings.MonthlyExplanationText);
                promptBuilder.AppendLine();
                
                // 按完成时间分组，按周汇总
                var tasksByWeek = recentCompletedTasks
                    .GroupBy(task => {
                        // 计算完成时间所在的周
                        DateTime completionDate = task.完成时间.Value;
                        return new { 
                            Year = completionDate.Year,
                            Week = (completionDate.DayOfYear / 7) + 1
                        };
                    })
                    .OrderByDescending(group => group.Key.Year)
                    .ThenByDescending(group => group.Key.Week);
                
                foreach (var weekGroup in tasksByWeek)
                {
                    // 获取该周的第一个任务和最后一个任务的完成时间
                    var firstTask = weekGroup.OrderBy(t => t.完成时间).First();
                    var lastTask = weekGroup.OrderBy(t => t.完成时间).Last();
                    
                    // 添加周区间标题
                    promptBuilder.AppendLine($"## {firstTask.完成时间.Value.ToString("yyyy-MM-dd")} 至 {lastTask.完成时间.Value.ToString("yyyy-MM-dd")} 完成的任务：");
                    
                    int index = 1;
                    foreach (var task in weekGroup.OrderByDescending(t => t.完成时间))
                    {
                        // 添加完成日期和时间
                        string completionTime = task.完成时间.HasValue ? 
                            task.完成时间.Value.ToString("yyyy-MM-dd HH:mm") : "未知时间";
                        
                        // 添加任务描述
                        promptBuilder.AppendLine($"{index}. {task.描述} (完成于: {completionTime})");
                        
                        // 如果有备注，也添加进去
                        if (!string.IsNullOrWhiteSpace(task.备注))
                        {
                            promptBuilder.AppendLine($"   备注: {task.备注}");
                        }
                        
                        index++;
                    }
                    
                    promptBuilder.AppendLine();
                }
                
                // 将提示词内容复制到剪贴板
                string promptText = promptBuilder.ToString();
                Clipboard.SetText(promptText);
                
                // 询问用户是否要编辑提示词
                DialogResult result = MessageBox.Show(
                    "月报提示词已生成并复制到剪贴板。是否要编辑提示词？", 
                    "月报提示词已生成", 
                    MessageBoxButtons.YesNo, 
                    MessageBoxIcon.Information);
                
                if (result == DialogResult.Yes)
                {
                    // 显示编辑提示词的窗口
                    using (var editPromptForm = new EditPromptForm(promptText))
                    {
                        if (editPromptForm.ShowDialog() == DialogResult.OK)
                        {
                            // 用户修改了提示词，更新剪贴板
                            Clipboard.SetText(editPromptForm.PromptText);
                            MessageBox.Show("修改后的月报提示词已复制到剪贴板。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                    }
                }
                
                Logger.Log("生成月报提示词成功", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("生成月报提示词失败", ex);
                MessageBox.Show($"生成月报提示词失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 根据任务类型对todoList1进行排序，使"有价值工作"类型的任务显示在列表顶部
        private void SortTodoListByTaskType()
        {
            if (upTasks == null || upTasks.Count <= 1)
                return;

            try
            {
                Logger.Log("开始按任务类型排序", LogLevel.Info);
                
                // 由于BindingList无法直接排序，需要使用临时列表
                var tempList = upTasks.OrderByDescending(task => task.任务类型 == TaskType.UP类)
                                     .ThenByDescending(task => task.任务类型 == TaskType.jump类)
                                     .ToList();
                
                // 清空并重新添加排序后的任务
                using (dataGridView1.SuspendBinding())
                {
                    upTasks.Clear();
                    foreach (var task in tempList)
                    {
                        upTasks.Add(task);
                    }
                }
                
                Logger.Log("任务类型排序完成", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("任务类型排序失败", ex);
            }
        }

        public async Task LoadAllDataAsync()
        {
            try
            {
                // 记录开始加载时间（用于性能分析）
                var startTime = DateTime.Now;
                
                // 清空现有数据
                if (upTasks != null)
                    upTasks.Clear();
                if (jumpTasks != null)
                    jumpTasks.Clear();
                if (otherTasks != null)
                    otherTasks.Clear();
                if (completedTasks != null)
                    completedTasks.Clear();

                // 记录加载路径
                string primaryPath = dataManager.GetDataFilePath(Constants.NormalTasksFile);
                Logger.Log($"从主数据路径加载任务: {primaryPath}", LogLevel.Info);

                // 并行加载数据以提高性能
                var loadingTasks = new[]
                {
                    dataManager.LoadDataAsync(Constants.NormalTasksFile),
                    dataManager.LoadDataAsync(Constants.CompletedTasksFile)
                };
                
                // 等待所有加载任务完成
                await Task.WhenAll(loadingTasks);
                
                // 获取加载结果
                var tasks = await loadingTasks[0];
                var completed = await loadingTasks[1];

                // 显示加载的数据条目数量
                Logger.Log($"已加载待办任务: {(tasks != null ? tasks.Count : 0)} 条", LogLevel.Info);
                Logger.Log($"已加载已完成任务: {(completed != null ? completed.Count : 0)} 条", LogLevel.Info);

                // 确保加载的数据有效
                if (tasks != null)
                {
                    // 如果数据列表尚未初始化则创建它们
                    if (upTasks == null)
                    {
                        upTasks = new BindingList<TodoItem>();
                        dataGridView1.DataSource = upTasks;
                    }
                    if (jumpTasks == null)
                    {
                        jumpTasks = new BindingList<TodoItem>();
                        dataGridView2.DataSource = jumpTasks;
                    }
                    if (otherTasks == null)
                    {
                        otherTasks = new BindingList<TodoItem>();
                        dataGridView3.DataSource = otherTasks;
                    }

                    // 根据任务类型分别添加到不同的列表中
                    using (dataGridView1.SuspendBinding())
                    using (dataGridView2.SuspendBinding())
                    using (dataGridView3.SuspendBinding())
                    {
                        foreach (var task in tasks)
                        {
                            switch (task.任务类型)
                            {
                                case TaskType.UP类:
                                    upTasks.Add(task);
                                    break;
                                case TaskType.jump类:
                                    jumpTasks.Add(task);
                                    break;
                                case TaskType.其他类:
                                default:
                                    otherTasks.Add(task);
                                    break;
                            }
                        }
                    }
                }
                else
                {
                    // 如果加载失败则创建空列表
                    Logger.LogError("加载待办任务失败，创建空列表", null);
                    upTasks = new BindingList<TodoItem>();
                    jumpTasks = new BindingList<TodoItem>();
                    otherTasks = new BindingList<TodoItem>();
                    dataGridView1.DataSource = upTasks;
                    dataGridView2.DataSource = jumpTasks;
                    dataGridView3.DataSource = otherTasks;
                }

                if (completed != null)
                {
                    // 如果数据列表尚未初始化则创建它
                    if (completedTasks == null)
                    {
                        completedTasks = new BindingList<TodoItem>();
                        dataGridView4.DataSource = completedTasks;
                    }

                    // 使用AddRange批量添加任务以提高性能
                    using (dataGridView4.SuspendBinding())
                    {
                        foreach (var task in completed)
                        {
                            completedTasks.Add(task);
                        }
                    }
                }
                else
                {
                    // 如果加载失败则创建空列表
                    Logger.LogError("加载已完成任务失败，创建空列表", null);
                    completedTasks = new BindingList<TodoItem>();
                    dataGridView4.DataSource = completedTasks;
                }

                // 使用批量刷新优化
                this.SuspendLayout();
                
                // 刷新DataGridView
                dataGridView1.Refresh();
                dataGridView2.Refresh();
                dataGridView3.Refresh();
                dataGridView4.Refresh();

                // 根据任务类型对待办任务列表进行排序
                SortTodoListByTaskType();
                
                this.ResumeLayout();

                // 计算并记录加载时间
                var loadTime = DateTime.Now - startTime;
                Logger.Log($"所有数据重新加载完成，耗时: {loadTime.TotalMilliseconds:F0}ms", LogLevel.Info);
                
                // 显示加载结果
                int todoCount = upTasks?.Count ?? 0;
                int completedCount = completedTasks?.Count ?? 0;
                
                // 如果没有任何数据且这不是首次启动，显示警告
                if (todoCount == 0 && completedCount == 0 && !isFirstLoad)
                {
                    MessageBox.Show($"警告：加载后未找到任何任务数据！\n\n" +
                        $"加载路径：{primaryPath}\n\n" +
                        $"请检查数据文件是否存在，或尝试使用其他备份文件恢复。", 
                        "数据加载警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
                else
                {
                    // 记录加载的任务数量
                    Logger.Log($"成功加载 {todoCount} 个待办任务和 {completedCount} 个已完成任务", LogLevel.Info);
                }
            }
            catch (Exception ex)
            {
                Logger.LogError("重新加载数据失败", ex);
                MessageBox.Show($"重新加载数据时发生错误: {ex.Message}\n\n" +
                    $"应用程序将尝试使用备份数据文件。", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                
                // 尝试从备份恢复
                TryRecoverFromBackup();
            }
            
            // 设置首次加载标志为false
            isFirstLoad = false;
        }

        // 尝试从最新备份中恢复数据
        private async Task TryRecoverFromBackup()
        {
            try
            {
                // 获取备份目录
                string backupDir = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
                    Constants.AppDataFolder,
                    "备份");
                
                if (!Directory.Exists(backupDir))
                {
                    Logger.Log("找不到备份目录，无法自动恢复", LogLevel.Warning);
                    return;
                }
                
                // 查找最新的待办任务备份
                var todoBackups = Directory.GetFiles(backupDir, "tasks_*.json")
                    .Select(f => new FileInfo(f))
                    .OrderByDescending(f => f.LastWriteTime)
                    .ToList();
                
                // 查找最新的已完成任务备份
                var completedBackups = Directory.GetFiles(backupDir, "completed_tasks_*.json")
                    .Select(f => new FileInfo(f))
                    .OrderByDescending(f => f.LastWriteTime)
                    .ToList();
                
                bool recoveryAttempted = false;
                
                // 尝试恢复待办任务
                if (todoBackups.Count > 0)
                {
                    var latestBackup = todoBackups[0];
                    Logger.Log($"尝试从备份恢复待办任务: {latestBackup.Name}", LogLevel.Info);
                    
                    string targetFile = dataManager.GetDataFilePath(Constants.NormalTasksFile);
                    File.Copy(latestBackup.FullName, targetFile, true);
                    recoveryAttempted = true;
                }
                
                // 尝试恢复已完成任务
                if (completedBackups.Count > 0)
                {
                    var latestBackup = completedBackups[0];
                    Logger.Log($"尝试从备份恢复已完成任务: {latestBackup.Name}", LogLevel.Info);
                    
                    string targetFile = dataManager.GetDataFilePath(Constants.CompletedTasksFile);
                    File.Copy(latestBackup.FullName, targetFile, true);
                    recoveryAttempted = true;
                }
                
                if (recoveryAttempted)
                {
                    MessageBox.Show("已尝试从最新备份恢复数据，将重新加载。", 
                        "自动恢复", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    
                    // 重新加载恢复的数据
                    await LoadAllDataAsync();
                }
            }
            catch (Exception ex)
            {
                Logger.LogError("从备份恢复数据失败", ex);
            }
        }

        // 此方法移除，因为数据恢复功能已移至设置面板
        private void btnDataRecovery_Click(object sender, EventArgs e)
        {
            // 此方法已移至设置面板，此处保留空方法以避免设计器引用错误
        }
        
        /// <summary>
        /// 重新加载所有数据（供外部调用）
        /// </summary>
        public async void ReloadAllData()
        {
            try
            {
                this.Cursor = Cursors.WaitCursor;
                
                // 保存当前可能的未保存更改
                SaveAllData();
                
                // 清空当前数据
                await LoadAllDataAsync();
                
                Logger.Log("通过设置面板手动重新加载所有数据", LogLevel.Info);
            }
            catch (Exception ex)
            {
                Logger.LogError("手动重新加载数据失败", ex);
                MessageBox.Show($"重新加载数据时发生错误: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                this.Cursor = Cursors.Default;
            }
        }
        
        // 调整原有的LoadAllData方法以使用新的异步方法
        private async void LoadAllData()
        {
            await LoadAllDataAsync();
        }
    }

    /// <summary>
    /// DataGridView 的扩展方法，用于提高性能
    /// </summary>
    public static class DataGridViewExtensions
    {
        /// <summary>
        /// 暂停数据绑定，提高批量操作性能
        /// </summary>
        public static IDisposable SuspendBinding(this DataGridView dataGridView)
        {
            return new DataGridViewBindingSuspender(dataGridView);
        }

        private class DataGridViewBindingSuspender : IDisposable
        {
            private readonly DataGridView _dataGridView;
            private readonly bool _originalVirtualMode;
            private readonly bool _originalAutoGenerateColumns;
            private readonly DataGridViewRowHeadersWidthSizeMode _originalRowHeadersWidthSizeMode;

            public DataGridViewBindingSuspender(DataGridView dataGridView)
            {
                _dataGridView = dataGridView;
                
                // 保存原始值
                _originalVirtualMode = dataGridView.VirtualMode;
                _originalAutoGenerateColumns = dataGridView.AutoGenerateColumns;
                _originalRowHeadersWidthSizeMode = dataGridView.RowHeadersWidthSizeMode;
                
                // 优化设置
                dataGridView.SuspendLayout();
                dataGridView.AutoGenerateColumns = false;
                dataGridView.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.DisableResizing;
            }

            public void Dispose()
            {
                // 恢复原始值
                _dataGridView.AutoGenerateColumns = _originalAutoGenerateColumns;
                _dataGridView.RowHeadersWidthSizeMode = _originalRowHeadersWidthSizeMode;
                _dataGridView.VirtualMode = _originalVirtualMode;
                _dataGridView.ResumeLayout();
            }
        }
    }
}
